
use crate::metadata::ir::*;
pub(crate) static REGISTERS: IR = IR {
    blocks: &[Block {
        name: "Adc",
        extends: None,
        description: Some("Analog-to-Digital Converter"),
        items: &[
            BlockItem {
                name: "isr",
                description: Some("interrupt and status register"),
                array: None,
                byte_offset: 0x0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Isr"),
                }),
            },
            BlockItem {
                name: "ier",
                description: Some("interrupt enable register"),
                array: None,
                byte_offset: 0x4,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Ier"),
                }),
            },
            BlockItem {
                name: "cr",
                description: Some("control register"),
                array: None,
                byte_offset: 0x8,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cr"),
                }),
            },
            BlockItem {
                name: "cfgr",
                description: Some("configuration register"),
                array: None,
                byte_offset: 0xc,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cfgr"),
                }),
            },
            BlockItem {
                name: "cfgr2",
                description: Some("configuration register"),
                array: None,
                byte_offset: 0x10,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Cfgr2"),
                }),
            },
            BlockItem {
                name: "smpr",
                description: Some("sample time register 1"),
                array: Some(Array::Regular(RegularArray { len: 2, stride: 4 })),
                byte_offset: 0x14,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Smpr"),
                }),
            },
            BlockItem {
                name: "tr",
                description: Some("watchdog threshold register 1"),
                array: Some(Array::Regular(RegularArray { len: 3, stride: 4 })),
                byte_offset: 0x20,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Tr"),
                }),
            },
            BlockItem {
                name: "sqr1",
                description: Some("regular sequence register 1"),
                array: None,
                byte_offset: 0x30,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Sqr1"),
                }),
            },
            BlockItem {
                name: "sqr2",
                description: Some("regular sequence register 2"),
                array: None,
                byte_offset: 0x34,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Sqr2"),
                }),
            },
            BlockItem {
                name: "sqr3",
                description: Some("regular sequence register 3"),
                array: None,
                byte_offset: 0x38,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Sqr3"),
                }),
            },
            BlockItem {
                name: "sqr4",
                description: Some("regular sequence register 4"),
                array: None,
                byte_offset: 0x3c,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Sqr4"),
                }),
            },
            BlockItem {
                name: "dr",
                description: Some("regular Data Register"),
                array: None,
                byte_offset: 0x40,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Dr"),
                }),
            },
            BlockItem {
                name: "jsqr",
                description: Some("injected sequence register"),
                array: None,
                byte_offset: 0x4c,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Jsqr"),
                }),
            },
            BlockItem {
                name: "ofr",
                description: Some("offset register 1"),
                array: Some(Array::Regular(RegularArray { len: 4, stride: 4 })),
                byte_offset: 0x60,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Ofr"),
                }),
            },
            BlockItem {
                name: "jdr",
                description: Some("injected data registers"),
                array: Some(Array::Regular(RegularArray { len: 4, stride: 4 })),
                byte_offset: 0x80,
                inner: BlockItemInner::Register(Register {
                    access: Access::Read,
                    bit_size: 32,
                    fieldset: Some("Jdr"),
                }),
            },
            BlockItem {
                name: "awd2cr",
                description: Some("Analog Watchdog 2 Configuration Register"),
                array: None,
                byte_offset: 0xa0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Awd2cr"),
                }),
            },
            BlockItem {
                name: "awd3cr",
                description: Some("Analog Watchdog 3 Configuration Register"),
                array: None,
                byte_offset: 0xa4,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Awd3cr"),
                }),
            },
            BlockItem {
                name: "difsel",
                description: Some("Differential Mode Selection Register 2"),
                array: None,
                byte_offset: 0xb0,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Difsel"),
                }),
            },
            BlockItem {
                name: "calfact",
                description: Some("Calibration Factors"),
                array: None,
                byte_offset: 0xb4,
                inner: BlockItemInner::Register(Register {
                    access: Access::ReadWrite,
                    bit_size: 32,
                    fieldset: Some("Calfact"),
                }),
            },
        ],
    }],
    fieldsets: &[
        FieldSet {
            name: "Awd2cr",
            extends: None,
            description: Some("Analog Watchdog 2 Configuration Register"),
            bit_size: 32,
            fields: &[Field {
                name: "awd2ch",
                description: Some("AWD2CH"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                bit_size: 18,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Awd3cr",
            extends: None,
            description: Some("Analog Watchdog 3 Configuration Register"),
            bit_size: 32,
            fields: &[Field {
                name: "awd3ch",
                description: Some("AWD3CH"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                bit_size: 18,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Calfact",
            extends: None,
            description: Some("Calibration Factors"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "calfact_s",
                    description: Some("CALFACT_S"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 7,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "calfact_d",
                    description: Some("CALFACT_D"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 7,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cfgr",
            extends: None,
            description: Some("configuration register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "dmaen",
                    description: Some("DMAEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "dmacfg",
                    description: Some("Direct memory access configuration"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: Some("Dmacfg"),
                },
                Field {
                    name: "res",
                    description: Some("RES"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 2,
                    array: None,
                    enumm: Some("Res"),
                },
                Field {
                    name: "align",
                    description: Some("ALIGN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "extsel",
                    description: Some("EXTSEL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "exten",
                    description: Some("EXTEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovrmod",
                    description: Some("OVRMOD"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 12 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "cont",
                    description: Some("CONT"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 13 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "autdly",
                    description: Some("AUTDLY"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 14 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "autoff",
                    description: Some("AUTOFF"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 15 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "discen",
                    description: Some("DISCEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "discnum",
                    description: Some("DISCNUM"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 17 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jdiscen",
                    description: Some("JDISCEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 20 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jqm",
                    description: Some("JQM"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 21 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1sgl",
                    description: Some("AWD1SGL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 22 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1en",
                    description: Some("AWD1EN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 23 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jawd1en",
                    description: Some("JAWD1EN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 24 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jauto",
                    description: Some("JAUTO"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 25 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awdch1ch",
                    description: Some("AWDCH1CH"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Cfgr2",
            extends: None,
            description: Some("configuration register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "rovse",
                    description: Some("Regular Oversampling Enable"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jovse",
                    description: Some("Injected Oversampling Enable"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovsr",
                    description: Some("Oversampling Ratio"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 3,
                    array: None,
                    enumm: Some("OversamplingRatio"),
                },
                Field {
                    name: "ovss",
                    description: Some("Oversampling Shift"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 4,
                    array: None,
                    enumm: Some("OversamplingShift"),
                },
                Field {
                    name: "trovs",
                    description: Some("Triggered Regular Oversampling"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 9 }),
                    bit_size: 1,
                    array: None,
                    enumm: Some("Trovs"),
                },
                Field {
                    name: "rovsm",
                    description: Some("Regular Oversampling Mode"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 1,
                    array: None,
                    enumm: Some("Rovsm"),
                },
            ],
        },
        FieldSet {
            name: "Cr",
            extends: None,
            description: Some("control register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "aden",
                    description: Some("ADEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "addis",
                    description: Some("ADDIS"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstart",
                    description: Some("ADSTART"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jadstart",
                    description: Some("JADSTART"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adstp",
                    description: Some("ADSTP"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jadstp",
                    description: Some("JADSTP"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "advregen",
                    description: Some("ADVREGEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 28 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "deeppwd",
                    description: Some("DEEPPWD"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 29 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adcaldif",
                    description: Some("ADCALDIF"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 30 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "adcal",
                    description: Some("ADCAL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Difsel",
            extends: None,
            description: Some("Differential Mode Selection Register 2"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "difsel_1_15",
                    description: Some("Differential mode for channels 15 to 1"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 15,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "difsel_16_18",
                    description: Some("Differential mode for channels 18 to 16"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 3,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Dr",
            extends: None,
            description: Some("regular Data Register"),
            bit_size: 32,
            fields: &[Field {
                name: "regular_data",
                description: Some("regularDATA"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 16,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Ier",
            extends: None,
            description: Some("interrupt enable register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdyie",
                    description: Some("ADRDYIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmpie",
                    description: Some("EOSMPIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eocie",
                    description: Some("EOCIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosie",
                    description: Some("EOSIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovrie",
                    description: Some("OVRIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeocie",
                    description: Some("JEOCIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeosie",
                    description: Some("JEOSIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd1ie",
                    description: Some("AWD1IE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd2ie",
                    description: Some("AWD2IE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd3ie",
                    description: Some("AWD3IE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 9 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jqovfie",
                    description: Some("JQOVFIE"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Isr",
            extends: None,
            description: Some("interrupt and status register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "adrdy",
                    description: Some("ADRDY"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eosmp",
                    description: Some("EOSMP"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 1 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eoc",
                    description: Some("EOC"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "eos",
                    description: Some("EOS"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 3 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ovr",
                    description: Some("OVR"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 4 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeoc",
                    description: Some("JEOC"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 5 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jeos",
                    description: Some("JEOS"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "awd",
                    description: Some("AWD1"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 7 }),
                    bit_size: 1,
                    array: Some(Array::Regular(RegularArray { len: 3, stride: 1 })),
                    enumm: None,
                },
                Field {
                    name: "jqovf",
                    description: Some("JQOVF"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 10 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Jdr",
            extends: None,
            description: Some("injected data register 1"),
            bit_size: 32,
            fields: &[Field {
                name: "jdata",
                description: Some("JDATA1"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 16,
                array: None,
                enumm: None,
            }],
        },
        FieldSet {
            name: "Jsqr",
            extends: None,
            description: Some("injected sequence register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "jl",
                    description: Some("JL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jextsel",
                    description: Some("JEXTSEL"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 2 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jexten",
                    description: Some("JEXTEN"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 2,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "jsq",
                    description: Some("JSQ"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 8 }),
                    bit_size: 5,
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 6 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Ofr",
            extends: None,
            description: Some("offset register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "offset",
                    description: None,
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "offset_ch",
                    description: None,
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 26 }),
                    bit_size: 5,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "offset_en",
                    description: None,
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 31 }),
                    bit_size: 1,
                    array: None,
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Smpr",
            extends: None,
            description: Some("sample time register 1"),
            bit_size: 32,
            fields: &[Field {
                name: "smp",
                description: Some("Channel 0 sampling time selection"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 3,
                array: Some(Array::Regular(RegularArray { len: 10, stride: 3 })),
                enumm: Some("SampleTime"),
            }],
        },
        FieldSet {
            name: "Sqr1",
            extends: None,
            description: Some("regular sequence register 1"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "l",
                    description: Some("Regular channel sequence length"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 4,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "sq",
                    description: Some("SQ1"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 6 }),
                    bit_size: 5,
                    array: Some(Array::Regular(RegularArray { len: 4, stride: 6 })),
                    enumm: None,
                },
            ],
        },
        FieldSet {
            name: "Sqr2",
            extends: None,
            description: Some("regular sequence register 2"),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ5"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 5, stride: 6 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Sqr3",
            extends: None,
            description: Some("regular sequence register 3"),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ10"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 5, stride: 6 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Sqr4",
            extends: None,
            description: Some("regular sequence register 4"),
            bit_size: 32,
            fields: &[Field {
                name: "sq",
                description: Some("SQ15"),
                bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                bit_size: 5,
                array: Some(Array::Regular(RegularArray { len: 2, stride: 6 })),
                enumm: None,
            }],
        },
        FieldSet {
            name: "Tr",
            extends: None,
            description: Some("watchdog threshold register"),
            bit_size: 32,
            fields: &[
                Field {
                    name: "lt",
                    description: Some("LT1"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 0 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
                Field {
                    name: "ht",
                    description: Some("HT1"),
                    bit_offset: BitOffset::Regular(RegularBitOffset { offset: 16 }),
                    bit_size: 12,
                    array: None,
                    enumm: None,
                },
            ],
        },
    ],
    enums: &[
        Enum {
            name: "Dmacfg",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "ONE_SHOT",
                    description: Some("DMA One Shot mode selected"),
                    value: 0,
                },
                EnumVariant {
                    name: "CIRCULAR",
                    description: Some("DMA Circular mode selected"),
                    value: 1,
                },
            ],
        },
        Enum {
            name: "OversamplingRatio",
            description: None,
            bit_size: 3,
            variants: &[
                EnumVariant {
                    name: "RATIO2",
                    description: Some("2x Oversampling Ratio"),
                    value: 0,
                },
                EnumVariant {
                    name: "RATIO4",
                    description: Some("4x Oversampling Ratio"),
                    value: 1,
                },
                EnumVariant {
                    name: "RATIO8",
                    description: Some("8x Oversampling Ratio"),
                    value: 2,
                },
                EnumVariant {
                    name: "RATIO16",
                    description: Some("16x Oversampling Ratio"),
                    value: 3,
                },
                EnumVariant {
                    name: "RATIO32",
                    description: Some("32x Oversampling Ratio"),
                    value: 4,
                },
                EnumVariant {
                    name: "RATIO64",
                    description: Some("64x Oversampling Ratio"),
                    value: 5,
                },
                EnumVariant {
                    name: "RATIO128",
                    description: Some("128x Oversampling Ratio"),
                    value: 6,
                },
                EnumVariant {
                    name: "RATIO256",
                    description: Some("256x Oversampling Ratio"),
                    value: 7,
                },
            ],
        },
        Enum {
            name: "OversamplingShift",
            description: None,
            bit_size: 4,
            variants: &[
                EnumVariant {
                    name: "SHIFT0",
                    description: Some("No shift"),
                    value: 0,
                },
                EnumVariant {
                    name: "SHIFT1",
                    description: Some("Shift 1-bit"),
                    value: 1,
                },
                EnumVariant {
                    name: "SHIFT2",
                    description: Some("Shift 2-bits"),
                    value: 2,
                },
                EnumVariant {
                    name: "SHIFT3",
                    description: Some("Shift 3-bits"),
                    value: 3,
                },
                EnumVariant {
                    name: "SHIFT4",
                    description: Some("Shift 4-bits"),
                    value: 4,
                },
                EnumVariant {
                    name: "SHIFT5",
                    description: Some("Shift 5-bits"),
                    value: 5,
                },
                EnumVariant {
                    name: "SHIFT6",
                    description: Some("Shift 6-bits"),
                    value: 6,
                },
                EnumVariant {
                    name: "SHIFT7",
                    description: Some("Shift 7-bits"),
                    value: 7,
                },
                EnumVariant {
                    name: "SHIFT8",
                    description: Some("Shift 8-bits"),
                    value: 8,
                },
            ],
        },
        Enum {
            name: "Res",
            description: None,
            bit_size: 2,
            variants: &[
                EnumVariant {
                    name: "BITS12",
                    description: Some("12-bit resolution"),
                    value: 0,
                },
                EnumVariant {
                    name: "BITS10",
                    description: Some("10-bit resolution"),
                    value: 1,
                },
                EnumVariant {
                    name: "BITS8",
                    description: Some("8-bit resolution"),
                    value: 2,
                },
                EnumVariant {
                    name: "BITS6",
                    description: Some("6-bit resolution"),
                    value: 3,
                },
            ],
        },
        Enum {
            name: "Rovsm",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "CONTINUED",
                    description: Some("Oversampling is temporarily stopped and continued after injection sequence"),
                    value: 0,
                },
                EnumVariant {
                    name: "RESUMED",
                    description: Some("Oversampling is aborted and resumed from start after injection sequence"),
                    value: 1,
                },
            ],
        },
        Enum {
            name: "SampleTime",
            description: None,
            bit_size: 3,
            variants: &[
                EnumVariant {
                    name: "CYCLES2_5",
                    description: Some("2.5 ADC cycles"),
                    value: 0,
                },
                EnumVariant {
                    name: "CYCLES6_5",
                    description: Some("6.5 ADC cycles"),
                    value: 1,
                },
                EnumVariant {
                    name: "CYCLES12_5",
                    description: Some("12.5 ADC cycles"),
                    value: 2,
                },
                EnumVariant {
                    name: "CYCLES24_5",
                    description: Some("24.5 ADC cycles"),
                    value: 3,
                },
                EnumVariant {
                    name: "CYCLES47_5",
                    description: Some("47.5 ADC cycles"),
                    value: 4,
                },
                EnumVariant {
                    name: "CYCLES92_5",
                    description: Some("92.5 ADC cycles"),
                    value: 5,
                },
                EnumVariant {
                    name: "CYCLES247_5",
                    description: Some("247.5 ADC cycles"),
                    value: 6,
                },
                EnumVariant {
                    name: "CYCLES640_5",
                    description: Some("640.5 ADC cycles"),
                    value: 7,
                },
            ],
        },
        Enum {
            name: "Trovs",
            description: None,
            bit_size: 1,
            variants: &[
                EnumVariant {
                    name: "AUTOMATIC",
                    description: Some(
                        "All oversampled conversions for a channel are done consecutively following a trigger",
                    ),
                    value: 0,
                },
                EnumVariant {
                    name: "TRIGGERED",
                    description: Some("Each oversampled conversion for a channel needs a new trigger"),
                    value: 1,
                },
            ],
        },
    ],
};
